package com.ply.flashsalessystem.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.ply.flashsalessystem.entity.pojo.OrderForGoods;
import com.ply.flashsalessystem.entity.pojo.ReturnOfGoods;
import com.ply.flashsalessystem.entity.pojo.ReturnOfGoodsDetails;
import com.ply.flashsalessystem.entity.pojo.UserAmount;
import com.ply.flashsalessystem.entity.status.ReturnOrderDetailsStatus;
import com.ply.flashsalessystem.entity.status.ReturnOrderStatus;
import com.ply.flashsalessystem.entity.vo.user.ReturnOrderVo;
import com.ply.flashsalessystem.entity.wrapper.WrapperOrder;
import com.ply.flashsalessystem.mapper.OrderForGoodsMapper;
import com.ply.flashsalessystem.mapper.ReturnOfGoodsDetailsMapper;
import com.ply.flashsalessystem.mapper.ReturnOfGoodsMapper;
import com.ply.flashsalessystem.service.ReturnOfGoodsDetailsService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.ply.flashsalessystem.service.UserAmountService;
import com.ply.flashsalessystem.utils.UserUtils;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.management.Query;
import java.util.List;
import java.util.Objects;

/**
 * <p>
 * 服务实现类
 * </p>
 *
 * @author XiaoPan
 * @since 2022-03-23
 */
@Service
@Slf4j
public class ReturnOfGoodsDetailsServiceImpl extends ServiceImpl<ReturnOfGoodsDetailsMapper, ReturnOfGoodsDetails> implements ReturnOfGoodsDetailsService {
    @Autowired
    ReturnOfGoodsDetailsMapper returnOfGoodsDetailsMapper;

    @Autowired
    ReturnOfGoodsMapper returnOfGoodsMapper;

    @Autowired
    UserAmountService userAmountService;

    @Autowired
    OrderForGoodsMapper orderForGoodsMapper;

    /**
     * 同意退货请求
     *
     * @param rogDId 退货详情id
     */
    @Override
    @Transactional
    public boolean agreeReturnOrder(Integer rogDId) {
//        判断前提 这个退单详情id 是对的   并且这个退单详情 状态是  未处理
        judgeReturnQuestion(rogDId);
        //修改退单状态
        updateStatus(rogDId, ReturnOrderDetailsStatus.COMPLETE);

        ReturnOfGoodsDetails returnOfGoodsDetails = returnOfGoodsDetailsMapper.selectById(rogDId);
        //退单id
        Integer rogId = returnOfGoodsDetails.getRogId();
        //判断退单id 下的 所有退单详情 的状态 所有 都为 处理过的 将退单 状态 修改为 完成
        judgeR(rogId);

        //获取 用户id
        ReturnOfGoods returnOfGoods = returnOfGoodsMapper.selectById(rogId);
        Integer orgId = returnOfGoods.getOrgId();
        OrderForGoods orderForGoods = orderForGoodsMapper.selectById(orgId);
        Long userId = orderForGoods.getUserId();

        //增加用户账户 流水信息
        UserAmount userAmount = new UserAmount();
        userAmount.setUserId(userId);
        userAmount.setAmount(returnOfGoodsDetails.getAmount());
        if (!userAmountService.save(userAmount)) {
            throw new RuntimeException("增加用户账户 流水信息 失败");
        }
        ;
        return true;
    }

    /**
     * 拒绝退货请求
     *
     * @param rogDId 退货详情id
     */
    @Override
    public boolean disagreeReturnOrder(Integer rogDId) {
        judgeReturnQuestion(rogDId);
        //修改订单状态
        updateStatus(rogDId, ReturnOrderDetailsStatus.FAIL);
        return true;
    }

    /**
     * 查询 订单 所有
     *
     * @param current
     * @param limit
     * @param wrapperOrder
     */
    @Override
    public Page<ReturnOrderVo> queryReturn(Integer current, Integer limit, WrapperOrder wrapperOrder) {
        return returnOfGoodsDetailsMapper.queryReturn(new Page<>(current, limit), wrapperOrder);
    }

    /**
     * 根据 退单id  查询 退单 明细
     *
     * @param current
     * @param limit
     * @param roId
     * @return
     */
    @Override
    public Page<ReturnOrderVo> queryReOrderDetailsByRodId(Integer current, Integer limit, Integer roId) {
        return returnOfGoodsDetailsMapper.queryReOrderDetailsByRodId(new Page<>(current, limit), roId);
    }

    /**
     * 取消 退单
     *
     * @param roId
     */
    @Override
    public void cancelReturnOrder(Integer roId) {
        // 判断 这个 退单是该用户的吗
        ReturnOfGoods returnOfGoods = returnOfGoodsMapper.selectById(roId);
        // 退单状态
        Integer status = returnOfGoods.getStatus();
        //订单id
        Integer orgId1 = returnOfGoods.getOrgId();
        //查询订单
        OrderForGoods orderForGoods = orderForGoodsMapper.selectById(orgId1);
        // 查询用户id
        if (!Objects.equals(orderForGoods.getUserId(), UserUtils.getUserId())) {
            // 该退单 不是 该用户的
            throw new RuntimeException("退单id 错误");
        }
        if (!Objects.equals(status, ReturnOrderDetailsStatus.APPLYING)) {
            throw new RuntimeException("该退单 不允许 取消");
        }


        // 取消退单
        returnOfGoodsMapper.updateStatus(roId, ReturnOrderStatus.CANCEL);
        // 对于 退单详情 也应 所有 取消
        QueryWrapper<ReturnOfGoodsDetails> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("rog_id", roId);
        List<ReturnOfGoodsDetails> returnOfGoodsDetails = returnOfGoodsDetailsMapper.selectList(queryWrapper);
        for (ReturnOfGoodsDetails returnOfGoodsDetail : returnOfGoodsDetails) {
            returnOfGoodsDetailsMapper.updateStatus(returnOfGoodsDetail.getRogDId(), ReturnOrderDetailsStatus.CANCEL, null);
        }
    }


    /**
     * 处理 退货请求
     * 判断前提 这个退单详情id 是对的   并且这个退单详情 状态是  未处理
     *
     * @param rogDId 退货详情id
     */
    private void judgeReturnQuestion(Integer rogDId) {
        //判断 rogDId 是不是存在 并且  在service 中 判断
        ReturnOfGoodsDetails returnOfGoodsDetails = returnOfGoodsDetailsMapper.selectById(rogDId);
        if (returnOfGoodsDetails == null) {
            throw new RuntimeException("参数错误 rogDId: " + rogDId + ", 查询不到这个 退单id");
        }
        // 只有 退货详情的 状态 为 未处理 才可以 处理 退货请求
        if (!ReturnOrderDetailsStatus.APPLYING.equals(returnOfGoodsDetails.getStatus())) {
            throw new RuntimeException("该 退货详情id 的状态 不运行同意 退货");
        }
    }

    //更新 退单详情状态
    private void updateStatus(Integer rogDId, Integer status) {
        if (returnOfGoodsDetailsMapper.updateStatus(rogDId, status, UserUtils.getUserId()) == 0) {
            throw new RuntimeException("更新 退单详情状态 失败");
        }
        ;
    }


    /**
     * 判断 用户 退单 下的 所有退单 详情是不是 全部完成了
     * 判断退单id 下的 所有退单详情 的状态 所有 都为 处理过的 将退单 状态 修改为 完成
     *
     * @param rogId
     * @return
     */
    private void judgeR(Integer rogId) {
        List<ReturnOfGoodsDetails> returnOfGoodsDetails = returnOfGoodsDetailsMapper.queryByRogId(rogId);

        for (ReturnOfGoodsDetails returnOfGoodsDetail : returnOfGoodsDetails) {
            // 如果有 还在申请中的 就不用什么 操作
            if (Objects.equals(returnOfGoodsDetail.getStatus(), ReturnOrderDetailsStatus.APPLYING)) {
                return;
            }
        }
        // 说明 退货详情 请求都 处理过了 那么 将退货状态 修改为完成
        if (returnOfGoodsMapper.updateStatus(rogId, ReturnOrderStatus.COMPLETE) == 0) {
            throw new RuntimeException("退货状态 修改为完成 失败");
        }
        ;
    }
}
